For open-loop fading channels, diversity is often considered the only choice to mitigate the fading effects and improve the system reliability. While FEC (forward error correction) coding provides valuable time diversity, for a slow fading environment, space diversity/polarization proves to be more effective. The objective of the so-called space-time codes is to maximize the diversity gain.
There are basically two kinds of space-time codes: trellis codes and block codes. While trellis codes provide additional coding gain, they have drawbacks, namely: the decoder is more complex (since these codes work on the QAM symbols), and it is difficult to concatenate trellis space-time codes with powerful soft-decoding FEC codes, such as Turbo codes and convolutional codes. Space-time block codes (STBC) do not provide coding gain, but they are simple to decode (especially for those complex orthogonal design codes), and they can be naturally combined with other soft-decoding FEC codes. It is for these reasons that STBC (space-time block codes) are more practical and are widely adopted by numerous standards.
The best known STBC code was invented by Alamouti and Tarokh (U.S. Pat. No. 6,185,258) where the code matrix is presented as in Table 1 below.
TABLE 1The Alamouti codeTime tTime (t + T)Antenna 1s1s2Antenna 2−s2*s1*
This code has several properties, which makes it perfect for space diversity. The signals are orthogonal; hence full diversity is achieved at the receiver side. The transmit power is balanced between the two antennas (and the two time slots); hence a low cost power amplifier can be used, which in turn reduces the modem cost. Its code rate is 1; hence no throughput is sacrificed. Its maximum likelihood decoder is very simple, which makes the cost of an optimal decoder negligible.
Unfortunately, it was proven later that there are no such orthogonal codes existing for a system with more than two transmitter antennas. Therefore, the focus was shifted to the following two areas: designing orthogonal STBC codes with a code rate smaller than 1; and designing quasi-orthogonal STBC codes to maintain the property of code rate 1. While the first approach sacrifices the system throughput, the second approach sacrifices signal quality due to a loss of orthogonality.
There are several variations of the codes falling into the above categories, with focus on other areas such as power balancing and code rate manipulation; but no codes with the beauty of the Alamouti have been found.
Table 2 below is a first example of an STBC code for 4 transmit antennas (code-A). This is an orthogonal code having code rate 3/4. This code strives to maintain the orthogonality of the codes, thereby the diversity order and signal quality.
TABLE 2Code rate ¾ orthogonal code (Code-A)TimeTimeTimeTime t(t + T)(t + 2T)(t + 3T)Antenna 1s1−s2*−s3*xAntenna 2s2s1*xs3*Antenna 3s3xs1*−s2*Antenna 4x−s3s2s1
With this code, each received signal has a diversity order of 4. However, one weakness of this code is its code rate loss, which must be compensated in FEC codes. In other words, due to the rate loss in STBC, the code rate in FEC must be higher. This can cause problem for those powerful trellis codes at higher code rate, whose coding gain loss becomes significant when punctuation becomes excessive. Note that this code does not achieve full power balance across transmit antennas. There are other codes available that are able to overcome this weakness.
Table 3 contains a second example of an STBC code for 4 antenna applications (Code-B). This is a code rate 1 non-orthogonal code. This code strives to maintain the throughput of the system; thereby no coding gain will be lost at the FEC stage.
TABLE 3Code rate 1 non-orthogonal code (Code-B)TimeTimeTimeTime t(t + T)(t + 2T)(t + 3T)Antenna 1s1−s2*s3−s4*Antenna 2s2s1*s4s3*Antenna 3s3−s4*s1−s2*Antenna 4s4s3s2s1*
Since code-B is no longer an orthogonal code, its determinant suffers from mutual interference. Defining the equivalent channel matrix Q as
                              Q          =                      [                                                                                h                    1                                                                                        h                    2                                                                                        h                    3                                                                                        h                    4                                                                                                                    h                    2                    *                                                                                        -                                          h                      1                      *                                                                                                            h                    4                    *                                                                                        -                                          h                      3                      *                                                                                                                                        h                    3                                                                                        h                    4                                                                                        h                    1                                                                                        h                    2                                                                                                                    h                    4                    *                                                                                        -                                          h                      3                      *                                                                                                            h                    2                    *                                                                                        -                                          h                      1                      *                                                                                            ]                          ,                                  ⁢        then                            (        1        )                                                      r            →                    =                      Q            ⁢                          s              _                                      ,                            (        2        )            where r=[r1 r*2 r3 r*4]T, and s=[s1 s2 s3 s4]T. The determinant of Q is given by|Q|=A2−B2,  (3)where A=|h1|2+|h2|2+|h3|2+|h4|2, and B=2(Re(h1h*3)+Re(h2h4)) . The element of B2 represents the loss due to the loss of orthogonality. Since B2≧0, it always contributes negatively to the code performance.